package futbol.tacticas.concursantes.TacticaNewTeamVk;

import futbol.General;
import futbol.tacticas.*;
import futbol.tacticas.concursantes.Tactica;

import java.awt.Color;
import java.awt.Point;
import java.util.Vector;

/**
 *
 * @author Josevk
 */
public class TacticaNewTeamVk implements Tactica{
	private boolean[] cubiertos = {false,false,false,false,false,false,false,false,false,false,false,false};
	private boolean[] desmarcate = {false,false,false,false,false,false,false,false,false,false,false,false};
	private int xAnteriorBola=0;
	private int yAnteriorBola=0;
	private int nValores[][]={
            {-145,15,6},   //portero
            {-145,-15,6},  //lateral derecho
            {-90,90,7},  //central derecho
            {-115,40,5}, //central izkierdo        
            {-115,-40,5}, //lateral izkierdo
            {-90,-90,7},    //rombo bajo
            {-40,0,6},   //centro derecha
            {60,70,7},  //centro izkierda
            {95,20,5},   //rombo alto
            {115,-20,7},   //pichichi derecha
            {60,-70,7}   //pichichi izkierda  
        //El nueve se corregirï¿½ en el framework y dejarï¿½ como 7 mï¿½ximo
    };
	private double irA[][]={
            {-145,15,10},   //portero
            {-145,-15,10},  //lateral derecho
            {-90,90,10},  //central derecho
            {-115,40,10}, //central izkierdo        
            {-115,-40,10}, //lateral izkierdo
            {-90,-90,10},    //rombo bajo
            {-40,0,10},   //centro derecha
            {60,70,10},  //centro izkierda
            {95,20,10},   //rombo alto
            {115,-20,10},   //pichichi derecha
            {60,-70,10}   //pichichi izkierda  
	};
    public String getNombre(){
        return "NewTeamVK";
    }
    
    public Color getColor1(){
        return Color.red;
    }
    
    public Color getColor2(){
        return Color.white;
    }
    
    public Color getColorNumero(){
        return Color.green;
    }
    
    public int getFuerza(int n){
        return nValores[n][2];
    }
    public int getXInicial(int n){
        return nValores[n][0];
    }
    
    public int getYInicial(int n){
        return nValores[n][1];
    }
    
    public void inicializar(){
    	for (int i=0;i<11;i++){
    		desmarcate[i]=false;
     		irA[i][0]=nValores[i][0];
    		irA[i][1]=nValores[i][1];      
    		irA[i][2]=10;
    		}
    	} 
    
    public int voyACubrir(int jugador){
    	if (cubiertos[jugador]) return 0;
    	else
    	 {
    	 cubiertos[jugador]=true;	
    	 return jugador;
    	 }
    }
    
    public Vector<Comando> getComandos(SituacionJugadores sj){
        Vector<Comando> comandos=new Vector();
        for (int n=0;n<11;n++)
            comandos.add(new ComandoIrA(n, nValores[n][0], nValores[n][1]));
            inicializar();
            
            portero(sj.getBola());
           defensas(sj.getBola(), sj);
           delanteros(sj.getBola(),sj);
        /*donde colocarse*/
        interceptar(sj.getBola(), sj, comandos);
        for (int n=0;n<11;n++)if (desmarcate[n]==false)comandos.add(new ComandoIrA(n, irA[n][0], irA[n][1]));  
        
        /*fonde tirar*/
 //       for (int n=0;n<11;n++)
   //         comandos.add(new ComandoTiroAPuerta(n,0));
         chutar(sj.getBola(), sj, comandos);   
        return comandos;
    }
    

    
    /**/
    /*interceptar*/
    public void interceptar(Point bola,SituacionJugadores sj,Vector<Comando> com){
      	int i=1;
    	double zancada =0;
    	double pelotazo =0;
     	double distanciaBola = General.getDistancia(xAnteriorBola, yAnteriorBola, bola.getX(), bola.getY());
       	double anguloBola = General.getAngulo(xAnteriorBola, yAnteriorBola, bola.getX(), bola.getY());
        int jugadorAdelantado=0;
        xAnteriorBola= (int) bola.getX();
       	yAnteriorBola= (int) bola.getY();
    	Point misJ[]=sj.getMisJugadores();
      	while ((i<=12)){
       		pelotazo=distanciaBola*i;
    	    double px = bola.getX()+Math.cos(anguloBola)*distanciaBola*i;
    	    double py = bola.getY()+Math.sin(anguloBola)*distanciaBola*i;
    	    if ((Math.abs(px)<=160)&(Math.abs(py)<=120))
    	      {
    	      jugadorAdelantado =sj.getMiJugadorMasCerca(px, py);
    	      if ((jugadorAdelantado<0)|(jugadorAdelantado>10))jugadorAdelantado=8;
    	      Point jug= sj.getMisJugadores()[jugadorAdelantado];
    	      zancada = (10-nValores[jugadorAdelantado][2])*i;
    	      double distancia =General.getDistancia(px, py, jug.getX(),jug.getY());
    	    	if((px<-30)&(py>70)){
    	    		com.add(new ComandoIrA(2,px,py));
    	    		 desmarcate[2]=true;
    	    		return;
    	    	}
    	    	if((px<-30)&(py<-70)){
    	    		 desmarcate[5]=true;
    	    		com.add(new ComandoIrA(5,px,py));
    	    		return;
    	    	}    	      
    	    	if((px>30)&(py>70)){
    	    		com.add(new ComandoIrA(7,px,py));
    	    		 desmarcate[7]=true;
    	    		return;
    	    	}
    	    	if((px>30)&(py<-70)){
    	    		 desmarcate[10]=true;
    	    		com.add(new ComandoIrA(10,px,py));
    	    		return;
    	    	}    	      
    	      if (zancada+7>=distancia){
     	  		               com.add(new ComandoIrA(jugadorAdelantado,px,py));
     	  		               desmarcate[jugadorAdelantado]=true;
     	  	                      return;
     	  	                     }else   com.add(new ComandoIrA(jugadorAdelantado,bola.getX(),bola.getY()));
     	  	  
      	   }
    	    i=i+1;
       }
    }
    /*defensas*/
    public void defensas(Point bola,SituacionJugadores sj){
        int defensa = 3;
    	int i =0;
    	Point contrarios[]=sj.getContrario();
       
        
    	//lo ideal seria una funcion cubrir, que generase un plakaje de un jugador :)
        for (i = 0;i<=10;i++)cubiertos[i]=false;
        for (defensa =3;defensa<=4;defensa++){
        
          int contrario = voyACubrir( sj.getContrarioMasCerca(defensa));
          
          if (contrario!=0){
            double posix =(bola.getX()+160-contrarios[contrario].getX())/160;
            double posiy =(bola.getY()-contrarios[contrario].getY())/120;
            double anguloPosi = Math.atan(posiy/posix);
            double signo =- 1;
            if (defensa==4) signo=1;
            if ((contrarios[contrario].getX()<-80)&
            		((contrarios[contrario].getY()*signo)<1)&
            		((Math.abs(contrarios[contrario].getY()))<70))
              {
            	irA[defensa][0]=(contrarios[contrario].getX()+(Math.cos(anguloPosi)*15));
                irA[defensa][1]=(contrarios[contrario].getY()+(Math.sin(anguloPosi)*15));
                irA[defensa][2]=10;
              }
           }
        }  
    }
    /**/
    /*chutar*/
    public void chutar(Point bola,SituacionJugadores sj,Vector <Comando> comandos){
    int n=0;
    for (n=0;n<11;n++){
        if(sj.getMiJugadorMasCerca(bola.getX(),bola.getY())==n)
        if ((bola.getX()==0)&(bola.getY()==0))	{
        	comandos.add(new ComandoPase(sj.getMiJugadorMasCerca(bola.getX(),bola.getY()),6));
        }else{
        	switch (n) {
			case 0:
				int num =(int)(3.5-(Math.signum(bola.getY()))*1.5);
			    comandos.add(new ComandoPase(0,num));
                //comandos.add(new ComandoIrA((int) (2.5-(Math.signum(bola.getY())*1.5)),-155,Math.signum(bola.getY())*110));
				break;
			case 1:
				int num1 =(int)(3.5-(Math.signum(bola.getY()))*1.5);
			    comandos.add(new ComandoPase(1,num1));
            	break;
				
			case 2:
			    comandos.add(new ComandoPase(2,7));
				break;
			case 3:
			    comandos.add(new ComandoPase(3,2));
				break;
			case 4:
			    comandos.add(new ComandoPase(4,5));
				break;
			case 5:
			    comandos.add(new ComandoPase(5,10));
				break;
			case 6:
				int num3 =(int)(8.5-(Math.signum(bola.getY()))*1.5);
			    comandos.add(new ComandoPase(6,num3));
             	break;
			default:
	       comandos.add(new ComandoTiroAPuerta(n,0));
				
				break;
			}
        }	
       }
    }
    /**/      
    /*delanteros*/
    public void delanteros(Point bola,SituacionJugadores sj){
        int i = 0;
        Point contrarios[]=sj.getContrario();
        Point misJugadores[]=sj.getMisJugadores();
        
        for(i=7;i<=10;i++){
        	//si ne cubren
        	int defContrario = sj.getContrarioMasCerca(i);
        	
        	if ((Math.abs(contrarios[defContrario].getX()-misJugadores[i].getX() )<30)&
        	    (Math.abs(contrarios[defContrario].getY()-misJugadores[i].getY() )<30)&
        	    (Math.abs(getXInicial(i)-contrarios[defContrario].getX() )<40)&
        	    (Math.abs(getYInicial(i)-contrarios[defContrario].getY() )<40)&
        	    (cubiertos[defContrario]==false))
        	 {  
        		cubiertos[defContrario]=true;
        		double posix =(bola.getX()+contrarios[defContrario].getX())/160;
                double posiy =(bola.getY()-contrarios[defContrario].getY())/120;
                double grado =-1;
                if (bola.getX()>misJugadores[i].getX()) grado = 1;
                double anguloPosi = Math.atan(posiy/posix);            
                irA[i][0]=(contrarios[defContrario].getX()+(grado)*(Math.cos(anguloPosi)*15));
            	irA[i][1]=(contrarios[defContrario].getY()+(Math.sin(anguloPosi)*15));
            	irA[i][2]=10;
        	 }
        }
    }  
    
    /**/
    /*portero*/
    public void portero (Point bola){
    	double porteroX1=-145;
        double porteroY1=15;
    	double porteroX2=-145;
        double porteroY2=-15;
                
        //si la bola pasa a mi campo, empiezo a moverlo, si no ahorro 5 instrucciones
        
        if (bola.getX()<0){
          double muevox =(bola.getX()+160)/160;
          double muevoy =bola.getY()/120;
          double anguloBola = Math.atan(muevoy/muevox);
          porteroY1 = (Math.sin(anguloBola)*17)+15;
          porteroX1 = (Math.cos(anguloBola)*12)-159;
          porteroY2 = (Math.sin(anguloBola)*17)-15;
          porteroX2 = (Math.cos(anguloBola)*12)-159;
            
        }
          
        //meto el comando
         if (bola.getY()>-40){
        	irA[0][0]= porteroX1;
        	irA[0][1]= porteroY1;
        	irA[0][2]=10;}
         if (bola.getY()<40){
           	irA[1][0]= porteroX2;
        	irA[1][1]= porteroY2;
        	irA[1][2]=10;
         }
    }
    /**/   

}
